{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 分类训练\n",
    "### 机器学习的Hello World，一个新的分类算法，都会看看在MNIST上的执行结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x00\\x00\\x00\\x02'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import struct\n",
    "struct.pack('>i', 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2051, 60000, 28, 28)\n",
      "47040000\n"
     ]
    }
   ],
   "source": [
    "with open(r'./MNIST/train-images.idx3-ubyte', 'rb') as f:\n",
    "    buffer = f.read(4*4) # 4个int\n",
    "    head = struct.unpack('>iiii', buffer)\n",
    "    print(head)\n",
    "    length = head[1] * head[2] * head[3]\n",
    "    print(length)\n",
    "    buffer = f.read(length)\n",
    "#     print(buffer)\n",
    "    data = struct.unpack('>{}B'.format(length), buffer)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47040000"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "imgs = np.reshape(data, (head[1], head[2], head[3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imgs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "for i in range(5):\n",
    "    plt.imshow(imgs[i], cmap = 'gray')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python37\\lib\\site-packages\\sklearn\\feature_extraction\\text.py:17: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working\n",
      "  from collections import Mapping, defaultdict\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'DESCR': 'mldata.org dataset: mnist-original',\n",
       " 'COL_NAMES': ['label', 'data'],\n",
       " 'target': array([0., 0., 0., ..., 9., 9., 9.]),\n",
       " 'data': array([[0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        ...,\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0],\n",
       "        [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.datasets import fetch_mldata\n",
    "mnist = fetch_mldata('MNIST original', data_home='./')\n",
    "mnist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   * DESCR 数据集描述\n",
    "   * COL_NAMES 列名\n",
    "   * target 标签(包含一个带有标签的数组)\n",
    "   * data 包含一个数组，每个实例为一行，每个特征为一列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, y = mnist['data'], mnist['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000, 784)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70000,)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_digit = X[36000]\n",
    "some_digit_image = some_digit.reshape(28, 28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x2052caedd48>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(some_digit_image, cmap = matplotlib.cm.binary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[36000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立训练集和测试集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([42457, 37897, 27203, ..., 52355, 45731,  5348])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 有些机器学习算法对训练实例的顺序敏感\n",
    "# 将数据集和交叉洗牌，交叉验证时，每个子集合数据分布均匀\n",
    "import numpy as np\n",
    "shuffle_index = np.random.permutation(60000)\n",
    "shuffle_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train = X_train[shuffle_index], y_train[shuffle_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       ...,\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0],\n",
       "       [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练一个二元分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 识别数字5，二元分类 5或者不是5\n",
    "y_train_5 = (y_train == 5)\n",
    "y_train_5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, ..., False,  True, False],\n",
       "       [ True, False, False, ..., False, False, False],\n",
       "       [ True, False,  True, ..., False, False, False],\n",
       "       ...,\n",
       "       [False, False, False, ..., False, False, False],\n",
       "       [False, False,  True, ...,  True, False, False],\n",
       "       [ True, False, False, ..., False, False, False]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_5.reshape(20, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SGD梯度下降分类器，适合非常大的数据集，独立处理训练集数据，一次一个，适合在线学习\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "\n",
    "sgd_clf = SGDClassifier(random_state = 42)\n",
    "sgd_clf.fit(X_train, y_train_5)\n",
    "\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 性能考核\n",
    "### 使用交叉验证测量精度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.96415, 0.92725, 0.9401 ])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 评估分类器比评估回归困难的多\n",
    "\n",
    "# 3个折叠，正确率达到 95%以上\n",
    "from sklearn.model_selection import cross_val_score\n",
    "cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring='accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 把每张图都分类成 非5\n",
    "from sklearn.base import BaseEstimator\n",
    "class Never5Classifier(BaseEstimator):\n",
    "    def fit(self, X, y=None):\n",
    "        pass\n",
    "    def predict(self, X):\n",
    "        return np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False],\n",
       "       [False],\n",
       "       [False],\n",
       "       ...,\n",
       "       [False],\n",
       "       [False],\n",
       "       [False]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((len(X), 1), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.9091 , 0.9103 , 0.90955])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "never_5_clf = Never5Classifier()\n",
    "cross_val_score(never_5_clf, X_train, y_train_5, cv=3, scoring='accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   * 准确率超过90%，因为5的图像大约只有10%，猜一张图片不是5,90%的时间你的判断是正确的\n",
    "   * 这说明精度/准确率无法成为分类器的首要性能指标，特别是当你处理偏科数据（某些类比其他类更加频繁）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 混淆矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 评估分类器性能的更好方法是混淆矩阵\n",
    "# A类别实例被分为B类别的次数（如判断是5被判断称非5的次数）\n",
    "# 想要知道分类器将3和5混淆多少次，通过混淆矩阵的5行3列\n",
    "\n",
    "from sklearn.model_selection import cross_val_predict\n",
    "\n",
    "y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 与cross_val_score 相比\n",
    "   * 同样执行交叉验证\n",
    "   * 返回的不是评估分数，是每个折叠的预测\n",
    "   * 每一个实例在模型预测使用的数据，在训练集从未见过\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[51967,  2612],\n",
       "       [  758,  4663]], dtype=int64)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "confusion_matrix(y_train_5, y_train_pred)  # confusion_matrix(实际类别，预测类别)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 行：实际类别，列：预测类别\n",
    "# 第一行 第一列 54168 被正确的分为 非5 ， 真负类    主要\n",
    "# 第一行 第二列 411   被错误的分为 5   ， 假正类\n",
    "# 第二行 第一列 2038  被错误的分为 非5 ， 假负类\n",
    "# 第二行 第二列 3383  被正确的分为 5   ，真正类     主要\n",
    "# 这种方式太复杂，我们可以用更简单的指标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[54579,     0],\n",
       "       [    0,  5421]], dtype=int64)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_perfect_predictions = y_train_5\n",
    "confusion_matrix(y_train_5, y_train_perfect_predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "## 正类预测的准确率 被称为分类器的精度\n",
    "\n",
    "\n",
    "$\n",
    "\\text{精度} = \\cfrac{TP}{TP + FP}\n",
    "$\n",
    "\n",
    "TP是真正类的数量，FP是假正类的数量\n",
    "\n",
    "\n",
    "\n",
    "$\n",
    "\\text{召回率TPR} = \\cfrac{TP}{TP + FN}\n",
    "$\n",
    "* 检测正类实例的比例\n",
    "FN是假负类的数量\n",
    "![jupyter](./zhaohui.jpg)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   * 精度率：预测标签中真正类占比\n",
    "   \n",
    "   * 召回率：实际标签中真正类占比"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度和召回率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6409621993127148"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import precision_score, recall_score\n",
    "\n",
    "precision_score(y_train_5, y_train_pred)  # 精度： 3716 / 3716 + 445"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8601733997417451"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred) # 召回： 3716 / 3716 + 1705"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   * 说明 检测一张图的时候，只有89%的概率是准确的（精度），而且只有68%的 数字5 被它检测出来（召回）\n",
    "   * 精度和召回率合成单一指标，成为 F1 分数，谐波平均值\n",
    "   * 平均值平等对待所有的值，谐波平均值会给予较低值更高的权重，只有召回率和精度都很高时，才能获得较高的F1分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 谐波平均值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   * 平均值平等对待所有的值，谐波平均值会给予较低值更高的权重，只有召回率和精度都很高时，才能获得较高的F1分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\n",
    "F_1 = \\cfrac{2}{\\cfrac{1}{\\text{precision}} + \\cfrac{1}{\\text{recall}}} = 2 \\times \\cfrac{\\text{precision}\\, \\times \\, \\text{recall}}{\\text{precision}\\, + \\, \\text{recall}} = \\cfrac{TP}{TP + \\cfrac{FN + FP}{2}}\n",
    "$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   * F1分数对那些具有相近精度和召回率 分类器更有利，这不一定符合你的期望\n",
    "   * 有时候你更关心精度，有时你能关心召回率\n",
    "   * 训练一个分类器检测儿童可以放心观看的视频，你可能要求拦截了很多好的视频，低召回率，保留下来的都是安全的视频，高精度\n",
    "   * 不能同时增加精度并减少召回率，反之亦然"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 精度/召回率权衡"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./quanheng.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* SGDClassifier对每个实例基于决策函数计算一个分值，大于阀值为正类，否则为负类\n",
    "* 中间阀值右侧找到4个真正类 真5 ， 一个假正类 6， 精度为 4/5 80%\n",
    "* 在所有的6个 真正的5 中，分类器找到了4个，召回率为 4/6 67%\n",
    "* 提高阀值，向右移动，精度提高，召回降低\n",
    "* 反之阀值降低，召回提高，精度降低\n",
    "* SKlearn不可以直接设置阀值，可以访问决策分数，\n",
    "* SGDClassifier 默认阀值为0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 如何设置阀值\n",
    "\n",
    "# 用predict_proba得到每个实例属于正类的概率，然后对概率切一下。以LogisticRegression为例\n",
    "# clf = LogisticRegression()\n",
    "# clf.fit(X_train, y_train)\n",
    "# pred_proba = clf.predict_proba(X_test)[:, 1]\n",
    "# threshold = 0.75  # 阀值设置为0.75\n",
    "# pred_label = pred_proba > threshold\n",
    "\n",
    "# pred_proba是每个实例为真的概率\n",
    "# 假设阈值是0.75\n",
    "# pred_label里True就是概率大于0.75的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-6827.05570634])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 返回决策值 decision_function\n",
    "y_scores = sgd_clf.decision_function([some_digit])\n",
    "y_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "threshold = 0\n",
    "y_some_digit_pred = (y_scores > threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 提高阀值可以降低召回率，提高阀值到200000，就错了这个图\n",
    "threshold = 200000\n",
    "y_some_digit_pred = (y_scores > threshold)\n",
    "y_some_digit_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "# 如何决定使用什么阀值\n",
    "# 返回决策值，而不是预测结果\n",
    "y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3,\n",
    "                             method=\"decision_function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000,)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 有了y_scores，可以计算所有可能的阀值的精度和召回率\n",
    "y_scores.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_recall_curve\n",
    "\n",
    "precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib 绘制精度和召回相对于阀值的函数图\n",
    "def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):\n",
    "    plt.plot(thresholds, precisions[:-1], \"b--\", label=\"Precision\", linewidth=2)\n",
    "    plt.plot(thresholds, recalls[:-1], \"g-\", label=\"Recall\", linewidth=2)\n",
    "    plt.xlabel(\"Threshold\", fontsize=16)\n",
    "    plt.legend(loc=\"upper left\", fontsize=16)\n",
    "    plt.ylim([0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 4))\n",
    "plot_precision_recall_vs_threshold(precisions, recalls, thresholds)\n",
    "plt.xlim([-700000, 700000])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   * 召回/精度曲线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_precision_vs_recall(precisions, recalls):\n",
    "    plt.plot(recalls, precisions, \"b-\", linewidth=2)\n",
    "    plt.xlabel(\"召回\", fontsize=16)\n",
    "    plt.ylabel(\"精度\", fontsize=16)\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_precision_vs_recall(precisions, recalls)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通过选择阀值来实现最佳的精度/召回率权衡"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 目标设定为90%的精度，阀值大概在 30000 左右\n",
    "y_train_pred_90 = (y_scores > 30000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7035128805620608"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "precision_score(y_train_5, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8312119535141118"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_90)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 获得了一个90%精度的分类器，但如果召回太低，精度再高，也不怎么有用\n",
    "* 如果工作中，需要99%的精度，你应该回应，召回率是多少？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC 曲线\n",
    "   * 本质是 真正类率tpr和假正类率fpr(错误的分为正类的负类的实例比例)\n",
    "   * 与召回/精度曲线非常相似"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_curve\n",
    "\n",
    "fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "def plot_roc_curve(fpr, tpr, label=None):\n",
    "    plt.plot(fpr, tpr, linewidth=2, label=label)\n",
    "    plt.plot([0, 1], [0, 1], 'k--')\n",
    "    plt.axis([0, 1, 0, 1])\n",
    "    plt.xlabel('假正类率', fontsize=16)\n",
    "    plt.ylabel('真正类率', fontsize=16)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plot_roc_curve(fpr, tpr)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9603942112156396"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算曲线下面积AUC，虚线是随机分类0.5到1\n",
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "roc_auc_score(y_train_5, y_scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 召回率TPR越高，分类器的假正类FPR就越多\n",
    "* 虚线表示纯随机分类器的ROC曲线，好的分类器应该远离这条线，向左上角\n",
    "* 是使用精度/召回率 PR曲线，还是使用ROC，关键在于 正类非常少或者更关注假正类而不是假负类，选择PR，反之ROC\n",
    "* 例如：前面例子ROC曲线很不错是因为跟负类 非5 相比， 正类 数据5 数量真的很少"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练随机森林分类器，比较SGD分类器的ROC曲线和ROC AUC分数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 获取训练集中每个实例的分数\n",
    "* RandomForestClassifier 没有descision_function(),但是拥有dict_proda()方法，sklearn中分类器都有这两个中的一个\n",
    "* dict_proda返回一个矩阵，每行一个实例，每列代表一个类别的概率，比如这个图片 70%是5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python37\\lib\\site-packages\\sklearn\\ensemble\\weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "forest_clf = RandomForestClassifier(n_estimators=10, random_state=42)\n",
    "y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3,\n",
    "                                    method=\"predict_proba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [1., 0.],\n",
       "       [1., 0.],\n",
       "       ...,\n",
       "       [1., 0.],\n",
       "       [1., 0.],\n",
       "       [1., 0.]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_probas_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 绘制ROC曲线，需要分数值/决策值 不是概率， 直接使用正类的概率作为分数值/决策值:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_scores_forest = y_probas_forest[:,1]\n",
    "fpr_forest, tpr_forest, thresolds_forest = roc_curve(y_train_5, y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., ..., 0., 0., 0.])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_scores_forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(fpr, tpr, \"b:\", linewidth=2, label=\"SGD\")\n",
    "plot_roc_curve(fpr_forest, tpr_forest, \"Random Forest\")\n",
    "plt.legend(loc=\"lower right\", fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9931766209000674"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Rand 比SGD 好很多，ROC AUC的分数也高很多\n",
    "roc_auc_score(y_train_5, y_scores_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9828797190517998"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 再看一下 精度和召回率 也很高\n",
    "y_train_pred_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3)\n",
    "precision_score(y_train_5, y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8260468548238332"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recall_score(y_train_5, y_train_pred_forest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "* 选择合适的指标利用交叉验证来对分类器进行评估\n",
    "* 选择满足需求的精度/召回率权衡\n",
    "* 使用ROC曲线和ROC AUC分数比较多个模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多类别分类器\n",
    "* 尝试5 之外的检测\n",
    "* 多类别分类器 区分两个以上的类别\n",
    "* 随机森林(RandomForestClassifier)和朴素贝叶斯(NaiveBayesianClassifier)可以直接处理多个类别\n",
    "* 支持向量机svm和线性分类器只可以处理二元分类器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 解决方案\n",
    "1. 将数字图片分类0到9，训练10个二元分类器，每个数字一个，检测一张图片时，获取每个分类器的决策分数，哪个最高属于哪个，称为一对多OvA\n",
    "2. 为每一对数字训练一个二元分类器，区分0，1 区分0，2 区分1，2 称为一对一OvO策略，存在N个类别，需要N*（N-1）/2个分类器，最后看哪个类别获胜最多\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 优缺点\n",
    "* OvO 只需要用到部分训练集对其必须区分两个类别进行训练\n",
    "* 对于较小训练集合OvO比较有优势， 大训练集合 OvA 速度快，所以OvA更常用，比如svm 在数据规模扩大时表现糟糕\n",
    "* sklearn 检查到使用二元分类算法进行多类别分类任务，会自动运行OvA，SVM分类器除外"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_clf.fit(X_train, y_train)\n",
    "sgd_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-118999.58689391, -453394.71699559, -296839.37075965,\n",
       "        -151208.20002961, -268845.19751653,   -6827.05570634,\n",
       "        -913349.75593906, -356180.7597792 , -646592.18745368,\n",
       "        -579205.46985999]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 内部实际上训练了10个二元分类器，获得图片的决策分数，然后选择了分数最高的类别\n",
    "# 返回10个分数，每个类别1个\n",
    "some_digit_scores = sgd_clf.decision_function([some_digit])\n",
    "some_digit_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(some_digit_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 目标类别列表会存储在classes_这个属性中，按值大小排列，\n",
    "sgd_clf.classes_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sgd_clf.classes_[np.argmax(some_digit_scores)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用OvO策略，一对一或者一对多\n",
    "from sklearn.multiclass import OneVsOneClassifier\n",
    "ovo_clf = OneVsOneClassifier(SGDClassifier(max_iter=5, tol=-np.infty, random_state=42))\n",
    "ovo_clf.fit(X_train, y_train)\n",
    "ovo_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ovo_clf.estimators_) # 使用了多少个二元分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用随机森林\n",
    "forest_clf.fit(X_train, y_train)\n",
    "forest_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0., 1., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机森林直接将实例分为多个类别，调用predict_proba()可以获得分类器将每个实例分类为每个类别的概率列表\n",
    "forest_clf.predict_proba([some_digit])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 评估分类器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.86367726, 0.86274314, 0.87258089])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用交叉验证评估SGD的准确率\n",
    "cross_val_score(sgd_clf, X_train, y_train, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.90926815, 0.90739537, 0.91253688])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 将输入进行简单缩放 ，可以得到准确率 90 %以上\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "scaler = StandardScaler()\n",
    "X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))\n",
    "cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring=\"accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 错误分析\n",
    "### 项目流程\n",
    "1. 探索数据准备的选项\n",
    "2. 尝试多个模型\n",
    "3. 选择最佳模型并用GridSearchCV对参数进行微调\n",
    "4. 尽可能自动化\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 确定了一个相对合适的模型，进一步优化，分析其错误类型\n",
    "* 查看混淆矩阵\n",
    "* 使用cross_val_predict()进行预测\n",
    "* 调用confusion_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n",
      "d:\\python37\\lib\\site-packages\\sklearn\\linear_model\\stochastic_gradient.py:128: FutureWarning: max_iter and tol parameters have been added in <class 'sklearn.linear_model.stochastic_gradient.SGDClassifier'> in 0.19. If both are left unset, they default to max_iter=5 and tol=None. If tol is not None, max_iter defaults to max_iter=1000. From 0.21, default max_iter will be 1000, and default tol will be 1e-3.\n",
      "  \"and default tol will be 1e-3.\" % type(self), FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[5729,    3,   22,    8,   10,   50,   49,   10,   38,    4],\n",
       "       [   1, 6477,   42,   28,    6,   40,    8,   13,  113,   14],\n",
       "       [  53,   32, 5317,  111,   81,   26,  100,   62,  158,   18],\n",
       "       [  45,   41,  138, 5329,    3,  235,   38,   66,  145,   91],\n",
       "       [  20,   29,   35,    7, 5377,   10,   53,   33,   77,  201],\n",
       "       [  67,   41,   34,  184,   69, 4612,  115,   32,  170,   97],\n",
       "       [  32,   24,   40,    2,   42,   85, 5646,    8,   38,    1],\n",
       "       [  22,   19,   70,   25,   50,   10,    6, 5839,   17,  207],\n",
       "       [  51,  162,   66,  153,   15,  165,   57,   26, 5007,  149],\n",
       "       [  42,   32,   27,   86,  159,   39,    3,  240,   70, 5251]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3)\n",
    "conf_mx = confusion_matrix(y_train, y_train_pred)\n",
    "conf_mx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib的matshow 函数来查看混淆矩阵的图像表示\n",
    "plt.matshow(conf_mx, cmap = plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 看起来不错，大多数图片都在主对角线上，说明它们被正确分类\n",
    "# 数字5 看起来比较暗\n",
    "# 说明: 1. 数字5图片较少  \n",
    "#       2. 分类器在数字5上执行效果不如其他数字上好\n",
    "# 假设把焦点放在错误上，为取得错误率，而不是错误绝对值，需要将混淆矩阵中每个值除以相应类别中的图片数量\n",
    "\n",
    "row_sums = conf_mx.sum(axis=1, keepdims=True)\n",
    "norm_conf_mx = conf_mx / row_sums"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 用0填充对角线 只保留错误，重新绘制\n",
    "np.fill_diagonal(norm_conf_mx, 0)\n",
    "plt.matshow(norm_conf_mx, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 每行代表实际类别，每列代表预测类别\n",
    "# 8，9列比较亮，说明许多图片被错误的分类为数字8，9\n",
    "# 类别8，9行也偏亮，说明数字8和9经常会跟其他数字混淆\n",
    "# 有些很暗，比如行1，大多数数字1都被正确的分类，一些和8混淆\n",
    "# 5和3是错误最多的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 结论\n",
    "* 改进数字8和9的分类\n",
    "* 修正数字3和5的混淆\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 如何优化分类器\n",
    "* 尝试多收集这些数字的训练集\n",
    "* 开发一些新特征来改进分类器\n",
    "* 优化分类器算法\n",
    "* 使用pillow或opencv对图片预处理，让显示模型更突出\n",
    "* 分析单个错误"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_digits(instances, images_per_row=10, **options):\n",
    "    size = 28\n",
    "    images_per_row = min(len(instances), images_per_row)\n",
    "    images = [instance.reshape(size,size) for instance in instances]\n",
    "    n_rows = (len(instances) - 1) // images_per_row + 1\n",
    "    row_images = []\n",
    "    n_empty = n_rows * images_per_row - len(instances)\n",
    "    images.append(np.zeros((size, size * n_empty)))\n",
    "    for row in range(n_rows):\n",
    "        rimages = images[row * images_per_row : (row + 1) * images_per_row]\n",
    "        row_images.append(np.concatenate(rimages, axis=1))\n",
    "    image = np.concatenate(row_images, axis=0)\n",
    "    plt.imshow(image, cmap = matplotlib.cm.binary, **options)\n",
    "    plt.axis(\"off\")\n",
    "\n",
    "\n",
    "# 查看数字3和数字5的例子\n",
    "cl_a, cl_b = 3, 5\n",
    "X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]\n",
    "X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)]\n",
    "X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]\n",
    "X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]\n",
    "\n",
    "plt.figure(figsize=(8,8))\n",
    "plt.subplot(221); \n",
    "plot_digits(X_aa[:25], images_per_row=5)\n",
    "plt.subplot(222); \n",
    "plot_digits(X_ab[:25], images_per_row=5)\n",
    "plt.subplot(223);\n",
    "plot_digits(X_ba[:25], images_per_row=5)\n",
    "plt.subplot(224); \n",
    "plot_digits(X_bb[:25], images_per_row=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 上侧两个是被分类为3的图片\n",
    "# 下侧两个是被分类为5的图片\n",
    "# 大多数错误分类的图片看起来还是非常明显的错误\n",
    "# 原因：SGD是一个线性模型，它所做就是为每个像素分配一个各个类别的权重，当它看到新的图像，将加权后的像素强度汇总，从而得到一个分数进行分类\n",
    "# 数字3和5在一部分像素位上有区别，所以分类器很容易将其弄混\n",
    "# 通过上面图像，如果书写3 的连接点左移，分类器可能将其分类为数字5，这个分类器对图像位移和旋转敏感\n",
    "# 减少混淆的方法之一，就是对图像进行预处理，确保位于中心位置并且没有旋转"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多标签分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 为每个实例产生多个类别 ，例如 照片识别多个人脸\n",
    "# 分类器经过训练可以识别小红，小白，小军，一张照片 里有 小红，小白\n",
    "# 经过分类器，应该输出[1,1,0]， 是小红，是小白，不是小军\n",
    "# 输出多个二元标签的分类系统称为多标签分类系统"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',\n",
       "           metric_params=None, n_jobs=1, n_neighbors=5, p=2,\n",
       "           weights='uniform')"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "y_train_large = (y_train >= 7)\n",
    "y_train_odd = (y_train % 2 == 1)\n",
    "y_multilabel = np.c_[y_train_large, y_train_odd]\n",
    "\n",
    "knn_clf = KNeighborsClassifier()\n",
    "knn_clf.fit(X_train, y_multilabel)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# knn支持多标签分类，不是所有的分类器都支持\n",
    "knn_clf.predict([some_digit])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 评估多标签分类器方法很多，方法之一就是测量每个标签的F1分数，或者其他二元分类器指标，然后简单平均\n",
    "# y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_multilabel, cv=3)\n",
    "# f1_score(y_multilabel, y_train_knn_pred, average=\"macro\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 上面假设了所有标签都同等重要，也可以给每个标签设置一个权重（该目标标签实例的数量）\n",
    "# 设置average='weighted'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 多输出分类\n",
    "### 例子：构建一个系统去除图片中的噪声，输入一张有噪声的图片，它将输入一张干净的数字图片，分类器输出是多个标签，一个像素一个标签，每个标签多个值0到255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 增加噪声，目标将图片还原为原始图片 创建训练集和测试集\n",
    "noise = np.random.randint(0, 100, (len(X_train), 784))\n",
    "X_train_mod = X_train + noise\n",
    "noise = np.random.randint(0, 100, (len(X_test), 784))\n",
    "X_test_mod = X_test + noise\n",
    "y_train_mod = X_train\n",
    "y_test_mod = X_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "some_index = 5500\n",
    "plt.subplot(121);plt.imshow(X_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.subplot(122);plt.imshow(y_test_mod[some_index].reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "knn_clf.fit(X_train_mod, y_train_mod)\n",
    "clean_digit = knn_clf.predict([X_test_mod[some_index]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPgAAAD2CAYAAAD720p7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAL20lEQVR4nO3dT4gcdRrG8efZZATJgCTaxChqDMSTMRAbyaCHCDFg8GBcRCFKZBcGctiDQnBFLyueVhBFUAkEDYKKghEPClFZ2REStUdW3Zx2WRIlJNBizPgHlqy8e0jvZpjJVPdUV/VU3nw/MFjdb3fX6w+e/KqraubniBCAnH6z1A0AqA8BBxIj4EBiBBxIjIADiS2vewdXXHFFrF27tu7dABe16enp7yKiNff52gO+du1adTqduncDXNRsHzvf86UP0W3vs33I9hPl2wJQp1IBt32PpGURMSFpne311bYFoAplZ/Atkt7sbR+UdNvsou1J2x3bnW63O0R7AIZRNuArJB3vbX8vafXsYkTsjYh2RLRbrXnf+wGMSNmA/yTp0t72+BCfA6BGZYM5rXOH5RslHa2kGwCVKnuZ7B1JU7avknSnpM3VtQSgKqVm8IiY0dkTbYcl3R4Rp6tsCkA1St/oEhGndO5MOoAG4uQYkBgBBxIj4EBiBBxIjIADiRFwIDECDiRGwIHECDiQGAEHEiPgQGIEHEiMgAOJEXAgMQIOJEbAgcQIOJAYAQcSI+BAYgQcSIyAA4kRcCAxAg4kRsCBxAg4kBgBBxIj4EBiBBxIjIADiS064LaX2/7G9se9nw11NAZgeGWWD75J0usR8WjVzQCoVplD9M2S7rL9me19tkuvMQ6gXmUC/rmkrRFxi6QxSdvnvsD2pO2O7U632x22RwAllQn4VxFxorfdkbR+7gsiYm9EtCOi3Wq1hmoQQHllAv6q7Y22l0m6W9KXFfcEoCJlvj8/Kek1SZb0bkR8WG1LAKqy6IBHxN919kw6gIbjRhcgMQIOJEbAgcQIOJAYAQcSI+BAYtxHDlTkzJkzhfWxsbERdXIOMziQGAEHEiPgQGIEHEiMgAOJEXAgMQIOJMZ18IvQsWPHCutHjhwprF977bWF9euuu27B2s8//1z43jVr1hTWn3766cL69PT0grU33nij8L07duworP/yyy+F9V27dhXWH3nkkQVrJ06cWLA2DGZwIDECDiRGwIHECDiQGAEHEiPgQGIEHEjMEVHrDtrtdnQ6nVr3cTGyvdQtXHTqzsowbE9HRHvu88zgQGIEHEiMgAOJEXAgMQIOJEbAgcQIOJAYvw/eUC+99NJSt7CgPXv2FNY3bNhQ275vvfXWwvq6detq2/eFiBkcSGyggNtebXtq1uN9tg/ZfqK+1gAMq2/Aba+UtF/Sit7jeyQti4gJSetsr6+3RQBlDTKD/yrpPkkzvcdbJL3Z2z4o6ba5b7A9abtju9PtdqvoE0AJfQMeETMRcXrWUyskHe9tfy9p9Xneszci2hHRbrVa1XQKYNHKnGT7SdKlve3xkp8BYATKhHNa5w7LN0o6Wlk3ACpV5jr4O5KmbF8l6U5Jm6tt6eJQ9Pe7JWn37t2lP7vfOtXLl3P7w8Vi4Bk8Irb0/jujsyfaDku6fc73cwANUuqf8og4pXNn0gE0FCfIgMQIOJAYAQcSI+BAYlwvqcnXX39dWG+35/2F20V55ZVXFqxxGQz/wwwOJEbAgcQIOJAYAQcSI+BAYgQcSIyAA4lxwbQmhw8frvXzH3rooQVru3btqnXfuHAwgwOJEXAgMQIOJEbAgcQIOJAYAQcSI+BAYlwHr8nk5OSS7fvZZ58trG/fvr2wfsMNN1TZDpYQMziQGAEHEiPgQGIEHEiMgAOJEXAgMQIOJMZ18JpERGH9hx9+KKy/9957hfWdO3cuWHv44YcL37tt27bC+sTERGH93nvvLawX3QMwPj5e+F5Ua6AZ3PZq21O97eW2v7H9ce9nQ70tAiir7wxue6Wk/ZJW9J66SdLrEfFonY0BGN4gM/ivku6TNNN7vFnSXbY/s73PNof5QEP1DXhEzETE6VlPfS5pa0TcImlM0rwbm21P2u7Y7nS73eq6BbAoZc6ifxURJ3rbHUnr574gIvZGRDsi2q1Wa6gGAZRXJuCv2t5oe5mkuyV9WXFPACpS5vvzk5Jek2RJ70bEh9W2BKAq7ne9dljtdjs6nU6t+0C19u/fX1gv+pvskrRjx44Fa2+//XaZltCH7emImLfoPHeyAYkRcCAxAg4kRsCBxAg4kBgBBxLjPnLMc/PNNxfWr7/++sL6gQMHFqx98cUXhe/dtGlTYR2LwwwOJEbAgcQIOJAYAQcSI+BAYgQcSIyAA4lxHRzz3HjjjYX1Tz75pLB+9dVXL1hbs2ZNqZ5QDjM4kBgBBxIj4EBiBBxIjIADiRFwIDECDiTGdXAs2qefflpYv/LKKxescR18tJjBgcQIOJAYAQcSI+BAYgQcSIyAA4kRcCAxroNjnlOnThXWn3rqqcL67t27q2wHQ+g7g9u+zPb7tg/aPmD7Etv7bB+y/cQomgRQziCH6DslPRMR2ySdlHS/pGURMSFpne31dTYIoLy+h+gR8cKshy1JD0h6tvf4oKTbJP2j+tYADGvgk2y2JyStlPStpOO9p7+XtPo8r5203bHd6Xa7lTQKYPEGCrjtVZKel/Q7ST9JurRXGj/fZ0TE3ohoR0S71WpV1SuARRrkJNslkt6S9FhEHJM0rbOH5ZK0UdLR2roDMJRBLpP9XtImSY/bflzSy5IetH2VpDslba6xPyyBVatWDfX+6enpijrBsAY5yfaipBdnP2f7XUl3SPpzRJyuqTcAQyp1o0tEnJL0ZsW9AKgYt6oCiRFwIDECDiRGwIHECDiQGL8uWpN+S/A+99xzhfWjR48W1q+55prFtvR/H330Uen3StLU1NRQ78foMIMDiRFwIDECDiRGwIHECDiQGAEHEiPgQGJcB6/JkSNHCutbt24dUSfz7dmzp7D+448/FtbHx8erbAc1YgYHEiPgQGIEHEiMgAOJEXAgMQIOJEbAgcS4Dl6TiCisnzlzprA+MzNTWD9+/PiCtZUrVxa+d5jfJceFhRkcSIyAA4kRcCAxAg4kRsCBxAg4kBgBBxLjOvgSGRsbK6xffvnlQ9UBaYCA275M0huSlkn6WdJ9kv4p6V+9l/whIr6urUMApQ1yiL5T0jMRsU3SSUl/lPR6RGzp/RBuoKH6BjwiXoiID3oPW5L+I+ku25/Z3md73lGA7UnbHdudbrdbccsABjXwSTbbE5JWSvpA0taIuEXSmKTtc18bEXsjoh0R7VarVVmzABZnoJNstldJel7SbyWdjIh/90odSetr6g3AkPrO4LYvkfSWpMci4pikV21vtL1M0t2Svqy5RwAlDXKI/ntJmyQ9bvtjSUckvSrpb5IORcSH9bUHYBh9D9Ej4kVJL855+k/1tAOgStzJBiRGwIHECDiQGAEHEiPgQGIEHEiMgAOJEXAgMQIOJEbAgcQIOJAYAQcSI+BAYgQcSMz9lrkdegd2V9KxWU9dIem7WndaHr2V09TemtqXVH1v10XEvL+PVnvA5+3Q7kREe6Q7HRC9ldPU3pralzS63jhEBxIj4EBiSxHwvUuwz0HRWzlN7a2pfUkj6m3k38EBjA6H6EBiBBxIbKQB761ldsj2E6Pcbz+2l9v+xvbHvZ8NS92TJNlebXtq1uNGjN/svpo0drYvs/2+7YO2D9i+pEFjdr7eah+3kQXc9j2SlkXEhKR1tpu05NFNatiKqbZXStovaUXvcSPGb25fatbYzV0J9341YMwW6G0kq/SOcgbfIunN3vZBSbeNcN/9bFafFVOXwK86uxb7TO/xFjVj/Ob21ZixO89KuA+oGWNWapXeKowy4CskHe9tfy9p9Qj33c/n6rNi6qhFxExEnJ71VCPG7zx9NW7sZq2E+60aMGazLWaV3iqM8l/bnyRd2tseV7NO8H11AayY2tTxa9TYzVkJ9xE1aMyWYpXeUf4PT+vcIdJGSUdHuO9+LoQVU5s6fo0Zu/OshNuYMVuqVXpHOYO/I2nK9lWS7tTZ725N8aSk1yRZ0rsNXTG1qePXpLGbvRLu45JelvRgQ8Zsbm9/0dlVemsdt5HeydY7A3uHpL9GxMmR7TgJxm/xLvYx41ZVILGmnKgBUAMCDiRGwIHECDiQGAEHEvsvpnAbIfXQFIQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(clean_digit.reshape(28, 28), cmap = matplotlib.cm.binary)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
